home *** CD-ROM | disk | FTP | other *** search
/ Windows News 2010 Summer - Disc 1 / WN_Ete2010_CD1.iso / Onglet5 / Weezo / Weezo setup.exe / {code_appDir} / www / js / BigInt-RSA-src.js next >
Text File  |  2010-05-19  |  22KB  |  857 lines
  1. /*
  2.  
  3.  My javascript implementation of the RSA algorithm, ported (partially)
  4.  from the PHP implementation found at http://www.edsko.net/. Using the
  5.  Big Integers library from http://www.ohdave.com/rsa/ (see BigInt.js
  6.  for details).
  7.  
  8.  Send any question, suggestion or remark to: jay.bertrand@free.fr
  9.  
  10.   ----------------------------------------------------------------------------
  11.  
  12.  This software is provided as-is, without express or implied warranty.
  13.  Permission to use, copy, modify, distribute or sell this software, with or
  14.  without fee, for any purpose and by any individual or organization, is hereby
  15.  granted, provided that the above copyright notice and this paragraph appear
  16.  in all copies. Distribution as a part of an application or binary must
  17.  include the above copyright notice in the documentation and/or other materials
  18.  provided with the application or distribution.
  19.  
  20.   ----------------------------------------------------------------------------
  21.  
  22.  Exemple of usage:
  23.  
  24.   // first set up the bigint library
  25.   // 76 is a good value for a 512 bits key
  26.   // (use 19 digits per 128 bits)
  27.   setMaxDigits(76);
  28.  
  29.   // prepare modulus and public exponent in hexa string format
  30.   // (i.e. each byte represented as hexa decimal digit)
  31.   var modulus = "0099d74e67d039f75654aea8d19fb199...16d";
  32.   var publicKey = "10001";
  33.  
  34.   // message holds data to encrypt, length must be
  35.   // maxi (key length in bits / 8 - 3)
  36.  
  37.   // convert the "string" into a "byte array"
  38.   var array = new Array();
  39.   for(var k=0; k<message.length; k++)
  40.     array.push(message.charCodeAt(k));
  41.  
  42.   array = rsa_encrypt(array, publicKey, modulus, 512);
  43.   alert("Crypted data (byte array): " + array + "(" + array.length + ")");
  44.  
  45. */
  46.  
  47.  
  48. // -------------------------------- Implementation details below
  49.  
  50. var JSCallback;
  51. var encryptPercNode;
  52. var RSAResult;
  53. var timed_div, timed_idx, timed_result, timed_base=0;
  54. var blocks=new Array();
  55. var cyphStep=0, modulus,public_key, block;
  56.  
  57. function RSACrypt(plainText,callback,percNode) {
  58.     if(plainText.length==0) return callback('');
  59.  
  60.     JSCallback=callback;
  61.     RSAResult='';
  62.     encryptPercNode=percNode;
  63.  
  64.     setMaxDigits(keyMaxDigits);
  65.     modulus = biFromDecimal(keyModulo);
  66.     public_key = biFromDecimal(keyPExp);
  67.  
  68.     var arr;
  69.     var i=0,o=0;
  70.     var blockSize=Math.ceil(keyLength/8);
  71.  
  72.     //var nbBlocks=Math.ceil(plainText.length/blockSize);
  73.     do{
  74.         block=plainText.substr(i, blockSize); i+=blockSize;
  75.         arr = new Array();
  76.         for(var k=0; k<block.length; k++) arr.push(block.charCodeAt(k));
  77.         blocks[o] = pow_mod(binary_to_number(arr), public_key, modulus);
  78.         o++;
  79.     }
  80.     while(i < plainText.length);
  81.  
  82.     // Monitor operation
  83.     timed_number_to_binary(keyLength/8,0,0);
  84. }
  85.  
  86. function timed_number_to_binary(blockSize, blockNumber, subStep) {
  87.     // Done
  88.     if(blockNumber>=blocks.length) return JSCallback('rsa:'+RSAResult);
  89.  
  90.     if(subStep==0){
  91.         timed_result = new Array();
  92.         if(!timed_base) timed_base=biFromNumber(256)
  93.         timed_div = biCopy(blocks[blockNumber]);
  94.         timed_idx = blockSize-1;
  95.     }
  96.  
  97.     if(biCompare(timed_div, bigZero) > 0) {
  98.         var mod = biModulo(timed_div, timed_base);
  99.         timed_div = biDivide(timed_div, timed_base);
  100.  
  101.         // /!\ mod is a big integer
  102.         timed_result[timed_idx--] = parseInt(biToString(mod, 10));
  103.         subStep++;
  104.  
  105.         if(encryptPercNode) encryptPercNode.innerHTML=Math.ceil(100*(subStep/blockSize+blockNumber)/blocks.length)+'%';
  106.         if(subStep%3==0) setTimeout('timed_number_to_binary('+blockSize+','+blockNumber+','+subStep+')',1);
  107.         else timed_number_to_binary(blockSize,blockNumber,subStep);
  108.     }
  109.     else {
  110.         RSAResult+=timed_result+';';
  111.         timed_number_to_binary(blockSize,blockNumber+1,0);
  112.     }
  113. }
  114.  
  115.  
  116.  
  117.  
  118.  
  119. //--
  120. // Computes (in a clever way ;-)) pow(p,q) mod r
  121. //--
  122. function pow_mod(p, q, r)
  123. {
  124.     // Extract powers of 2 from $q
  125.     var factors = new Array();
  126.     var power_of_two = 0;
  127.  
  128.     var TWO = biFromNumber(2);
  129.     var div = biCopy(q);
  130.  
  131.     while(biCompare(div, bigZero) == 1) {
  132.         rem = biModulo(div, TWO);
  133.         div = biDivide(div, TWO);
  134.  
  135.         if(biCompare(rem,bigOne)==0)
  136.             factors.push(power_of_two);
  137.         power_of_two++;
  138.     }
  139.  
  140.     // Calculate partial results for each factor, using each partial result as a
  141.     // starting point for the next. This depends of the factors of two being
  142.     // generated in increasing order.
  143.     partial_results = new Array();
  144.     part_res = biCopy(p);
  145.     idx = 0;
  146.  
  147.     for(k=0; k<factors.length; k++) {
  148.         factor = factors[k];
  149.         while(idx < factor)
  150.         {
  151.             part_res = biPow(part_res, 2);
  152.             part_res = biModulo(part_res, r);
  153.             idx++;
  154.         }
  155.  
  156.         partial_results.push(part_res);
  157.     }
  158.  
  159.     // Calculate final result
  160.     result = bigOne;
  161.     for(k=0; k<partial_results.length; k++) {
  162.         part_res = partial_results[k];
  163.         result = biMultiply(result, part_res);
  164.         result = biModulo(result, r);
  165.     }
  166.  
  167.     return result;
  168. }
  169.  
  170. //--
  171. // Function to add padding to a decrypted string
  172. // We need to know if this is a private or a public key operation [4]
  173. //--
  174. function add_PKCS1_padding(data, blocksize)
  175. {
  176.     var pad_length = blocksize - 3 - data.length;
  177.  
  178.     var result = new Array();
  179.     result.push(0);
  180.     result.push(2); // block type
  181.     for(i = 0; i < pad_length; i++)
  182.         result.push( Math.round(Math.random()*255) );
  183.     result.push(0);
  184.     result = result.concat(data);
  185.     return result;
  186. }
  187.  
  188. function binary_to_number(data)
  189. {
  190.     base = biFromNumber(256);
  191.     result = biFromNumber(0);
  192.     radix = biFromNumber(1);
  193.  
  194.     for(i = data.length-1; i >= 0; i--) {
  195.         digit = biFromNumber(data[i]);
  196.         part_res = biMultiply(digit, radix);
  197.         result = biAdd(result, part_res);
  198.         radix = biMultiply(radix, base);
  199.     }
  200.  
  201.     return result;
  202. }
  203.  
  204. function number_to_binary(number, blocksize) {
  205.  
  206.     var base = biFromNumber(256);
  207.     var result = new Array();
  208.     var div = biCopy(number);
  209.     var idx = blocksize-1;
  210.  
  211.     for(k=0; k<blocksize; k++)
  212.         result.push(0);
  213.  
  214.     while(biCompare(div, bigZero) > 0)
  215.     {
  216.         mod = biModulo(div, base);
  217.         div = biDivide(div, base);
  218.  
  219.         // /!\ mod is a big integer
  220.         result[idx--] = parseInt(biToString(mod, 10));
  221.     }
  222.     return result;
  223. }
  224.  
  225.  
  226.  
  227.  
  228. // BigInt, a suite of routines for performing multiple-precision arithmetic in
  229. // JavaScript.
  230. //
  231. // Copyright 1998-2005 David Shapiro.
  232. //
  233. // You may use, re-use, abuse,
  234. // copy, and modify this code to your liking, but please keep this header.
  235. // Thanks!
  236. //
  237. // Dave Shapiro
  238. // dave@ohdave.com
  239.  
  240. // IMPORTANT THING: Be sure to set maxDigits according to your precision
  241. // needs. Use the setMaxDigits() function to do this. See comments below.
  242. //
  243. // Tweaked by Ian Bunning
  244. // Alterations:
  245. // Fix bug in function biFromHex(s) to allow
  246. // parsing of strings of length != 0 (mod 4)
  247.  
  248. // Changes made by Dave Shapiro as of 12/30/2004:
  249. //
  250. // The BigInt() constructor doesn't take a string anymore. If you want to
  251. // create a BigInt from a string, use biFromDecimal() for base-10
  252. // representations, biFromHex() for base-16 representations, or
  253. // biFromString() for base-2-to-36 representations.
  254. //
  255. // biFromArray() has been removed. Use biCopy() instead, passing a BigInt
  256. // instead of an array.
  257. //
  258. // The BigInt() constructor now only constructs a zeroed-out array.
  259. // Alternatively, if you pass <true>, it won't construct any array. See the
  260. // biCopy() method for an example of this.
  261. //
  262. // Be sure to set maxDigits depending on your precision needs. The default
  263. // zeroed-out array ZERO_ARRAY is constructed inside the setMaxDigits()
  264. // function. So use this function to set the variable. DON'T JUST SET THE
  265. // VALUE. USE THE FUNCTION.
  266. //
  267. // ZERO_ARRAY exists to hopefully speed up construction of BigInts(). By
  268. // precalculating the zero array, we can just use slice(0) to make copies of
  269. // it. Presumably this calls faster native code, as opposed to setting the
  270. // elements one at a time. I have not done any timing tests to verify this
  271. // claim.
  272.  
  273. // Max number = 10^16 - 2 = 9999999999999998;
  274. //               2^53     = 9007199254740992;
  275.  
  276. var biRadixBase = 2;
  277. var biRadixBits = 16;
  278. var bitsPerDigit = biRadixBits;
  279. var biRadix = 1 << 16; // = 2^16 = 65536
  280. var biHalfRadix = biRadix >>> 1;
  281. var biRadixSquared = biRadix * biRadix;
  282. var maxDigitVal = biRadix - 1;
  283. var maxInteger = 9999999999999998;
  284.  
  285. // maxDigits:
  286. // Change this to accommodate your largest number size. Use setMaxDigits()
  287. // to change it!
  288. //
  289. // In general, if you're working with numbers of size N bits, you'll need 2*N
  290. // bits of storage. Each digit holds 16 bits. So, a 1024-bit key will need
  291. //
  292. // 1024 * 2 / 16 = 128 digits of storage.
  293. //
  294.  
  295. var maxDigits;
  296. var ZERO_ARRAY;
  297. var bigZero, bigOne;
  298.  
  299. function setMaxDigits(value)
  300. {
  301.     maxDigits = value;
  302.     ZERO_ARRAY = new Array(maxDigits);
  303.     for (var iza = 0; iza < ZERO_ARRAY.length; iza++) ZERO_ARRAY[iza] = 0;
  304.     bigZero = new BigInt();
  305.     bigOne = new BigInt();
  306.     bigOne.digits[0] = 1;
  307. }
  308.  
  309. setMaxDigits(20);
  310.  
  311. // The maximum number of digits in base 10 you can convert to an
  312. // integer without JavaScript throwing up on you.
  313. var dpl10 = 15;
  314. // lr10 = 10 ^ dpl10
  315. var lr10 = biFromNumber(1000000000000000);
  316.  
  317. function BigInt(flag)
  318. {
  319.     if (typeof flag == "boolean" && flag == true) {
  320.         this.digits = null;
  321.     }
  322.     else {
  323.         this.digits = ZERO_ARRAY.slice(0);
  324.     }
  325.     this.isNeg = false;
  326. }
  327.  
  328. function biFromDecimal(s)
  329. {
  330.     var isNeg = s.charAt(0) == '-';
  331.     var i = isNeg ? 1 : 0;
  332.     var result;
  333.     // Skip leading zeros.
  334.     while (i < s.length && s.charAt(i) == '0') ++i;
  335.     if (i == s.length) {
  336.         result = new BigInt();
  337.     }
  338.     else {
  339.         var digitCount = s.length - i;
  340.         var fgl = digitCount % dpl10;
  341.         if (fgl == 0) fgl = dpl10;
  342.         result = biFromNumber(Number(s.substr(i, fgl)));
  343.         i += fgl;
  344.         while (i < s.length) {
  345.             result = biAdd(biMultiply(result, lr10),
  346.                            biFromNumber(Number(s.substr(i, dpl10))));
  347.             i += dpl10;
  348.         }
  349.         result.isNeg = isNeg;
  350.     }
  351.     return result;
  352. }
  353.  
  354. function biCopy(bi)
  355. {
  356.     var result = new BigInt(true);
  357.     result.digits = bi.digits.slice(0);
  358.     result.isNeg = bi.isNeg;
  359.     return result;
  360. }
  361.  
  362. function biFromNumber(i)
  363. {
  364.     var result = new BigInt();
  365.     result.isNeg = i < 0;
  366.     i = Math.abs(i);
  367.     var j = 0;
  368.     while (i > 0) {
  369.         result.digits[j++] = i & maxDigitVal;
  370.         i = Math.floor(i / biRadix);
  371.     }
  372.     return result;
  373. }
  374.  
  375. function reverseStr(s)
  376. {
  377.     var result = "";
  378.     for (var i = s.length - 1; i > -1; --i) {
  379.         result += s.charAt(i);
  380.     }
  381.     return result;
  382. }
  383.  
  384. var hexatrigesimalToChar = new Array(
  385.  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  386.  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
  387.  'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
  388.  'u', 'v', 'w', 'x', 'y', 'z'
  389. );
  390.  
  391. function biToString(x, radix)
  392.     // 2 <= radix <= 36
  393. {
  394.     var b = new BigInt();
  395.     b.digits[0] = radix;
  396.     var qr = biDivideModulo(x, b);
  397.     var result = hexatrigesimalToChar[qr[1].digits[0]];
  398.     while (biCompare(qr[0], bigZero) == 1) {
  399.         qr = biDivideModulo(qr[0], b);
  400.         digit = qr[1].digits[0];
  401.         result += hexatrigesimalToChar[qr[1].digits[0]];
  402.     }
  403.     return (x.isNeg ? "-" : "") + reverseStr(result);
  404. }
  405.  
  406. function biToDecimal(x)
  407. {
  408.     var b = new BigInt();
  409.     b.digits[0] = 10;
  410.     var qr = biDivideModulo(x, b);
  411.     var result = String(qr[1].digits[0]);
  412.     while (biCompare(qr[0], bigZero) == 1) {
  413.         qr = biDivideModulo(qr[0], b);
  414.         result += String(qr[1].digits[0]);
  415.     }
  416.     return (x.isNeg ? "-" : "") + reverseStr(result);
  417. }
  418.  
  419. var hexToChar = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  420.                           'a', 'b', 'c', 'd', 'e', 'f');
  421.  
  422. function digitToHex(n)
  423. {
  424.     var mask = 0xf;
  425.     var result = "";
  426.     for (i = 0; i < 4; ++i) {
  427.         result += hexToChar[n & mask];
  428.         n >>>= 4;
  429.     }
  430.     return reverseStr(result);
  431. }
  432.  
  433. function biToHex(x)
  434. {
  435.     var result = "";
  436.     var n = biHighIndex(x);
  437.     for (var i = biHighIndex(x); i > -1; --i) {
  438.         result += digitToHex(x.digits[i]);
  439.     }
  440.     return result;
  441. }
  442.  
  443. function charToHex(c)
  444. {
  445.     var ZERO = 48;
  446.     var NINE = ZERO + 9;
  447.     var littleA = 97;
  448.     var littleZ = littleA + 25;
  449.     var bigA = 65;
  450.     var bigZ = 65 + 25;
  451.     var result;
  452.  
  453.     if (c >= ZERO && c <= NINE) {
  454.         result = c - ZERO;
  455.     } else if (c >= bigA && c <= bigZ) {
  456.         result = 10 + c - bigA;
  457.     } else if (c >= littleA && c <= littleZ) {
  458.         result = 10 + c - littleA;
  459.     } else {
  460.         result = 0;
  461.     }
  462.     return result;
  463. }
  464.  
  465. function hexToDigit(s)
  466. {
  467.     var result = 0;
  468.     var sl = Math.min(s.length, 4);
  469.     for (var i = 0; i < sl; ++i) {
  470.         result <<= 4;
  471.         result |= charToHex(s.charCodeAt(i))
  472.     }
  473.     return result;
  474. }
  475.  
  476. function biFromHex(s)
  477. {
  478.     var result = new BigInt();
  479.     var sl = s.length;
  480.     for (var i = sl, j = 0; i > 0; i -= 4, ++j) {
  481.         result.digits[j] = hexToDigit(s.substr(Math.max(i - 4, 0), Math.min(i, 4)));
  482.     }
  483.     return result;
  484. }
  485.  
  486. function biFromString(s, radix)
  487. {
  488.     var isNeg = s.charAt(0) == '-';
  489.     var istop = isNeg ? 1 : 0;
  490.     var result = new BigInt();
  491.     var place = new BigInt();
  492.     place.digits[0] = 1; // radix^0
  493.     for (var i = s.length - 1; i >= istop; i--) {
  494.         var c = s.charCodeAt(i);
  495.         var digit = charToHex(c);
  496.         var biDigit = biMultiplyDigit(place, digit);
  497.         result = biAdd(result, biDigit);
  498.         place = biMultiplyDigit(place, radix);
  499.     }
  500.     result.isNeg = isNeg;
  501.     return result;
  502. }
  503.  
  504. function biDump(b)
  505. {
  506.     return (b.isNeg ? "-" : "") + b.digits.join(" ");
  507. }
  508.  
  509. function biAdd(x, y)
  510. {
  511.     var result;
  512.  
  513.     if (x.isNeg != y.isNeg) {
  514.         y.isNeg = !y.isNeg;
  515.         result = biSubtract(x, y);
  516.         y.isNeg = !y.isNeg;
  517.     }
  518.     else {
  519.         result = new BigInt();
  520.         var c = 0;
  521.         var n;
  522.         for (var i = 0; i < x.digits.length; ++i) {
  523.             n = x.digits[i] + y.digits[i] + c;
  524.             result.digits[i] = n % biRadix;
  525.             c = Number(n >= biRadix);
  526.         }
  527.         result.isNeg = x.isNeg;
  528.     }
  529.     return result;
  530. }
  531.  
  532. function biSubtract(x, y)
  533. {
  534.     var result;
  535.     if (x.isNeg != y.isNeg) {
  536.         y.isNeg = !y.isNeg;
  537.         result = biAdd(x, y);
  538.         y.isNeg = !y.isNeg;
  539.     } else {
  540.         result = new BigInt();
  541.         var n, c;
  542.         c = 0;
  543.         for (var i = 0; i < x.digits.length; ++i) {
  544.             n = x.digits[i] - y.digits[i] + c;
  545.             result.digits[i] = n % biRadix;
  546.             // Stupid non-conforming modulus operation.
  547.             if (result.digits[i] < 0) result.digits[i] += biRadix;
  548.             c = 0 - Number(n < 0);
  549.         }
  550.         // Fix up the negative sign, if any.
  551.         if (c == -1) {
  552.             c = 0;
  553.             for (var i = 0; i < x.digits.length; ++i) {
  554.                 n = 0 - result.digits[i] + c;
  555.                 result.digits[i] = n % biRadix;
  556.                 // Stupid non-conforming modulus operation.
  557.                 if (result.digits[i] < 0) result.digits[i] += biRadix;
  558.                 c = 0 - Number(n < 0);
  559.             }
  560.             // Result is opposite sign of arguments.
  561.             result.isNeg = !x.isNeg;
  562.         } else {
  563.             // Result is same sign.
  564.             result.isNeg = x.isNeg;
  565.         }
  566.     }
  567.     return result;
  568. }
  569.  
  570. function biHighIndex(x)
  571. {
  572.     var result = x.digits.length - 1;
  573.     while (result > 0 && x.digits[result] == 0) --result;
  574.     return result;
  575. }
  576.  
  577. function biNumBits(x)
  578. {
  579.     var n = biHighIndex(x);
  580.     var d = x.digits[n];
  581.     var m = (n + 1) * bitsPerDigit;
  582.     var result;
  583.     for (result = m; result > m - bitsPerDigit; --result) {
  584.         if ((d & 0x8000) != 0) break;
  585.         d <<= 1;
  586.     }
  587.     return result;
  588. }
  589.  
  590. var inside_pow_mod = 0;
  591.  
  592. function biMultiply(x, y)
  593. {
  594.     var result = new BigInt();
  595.     var c;
  596.     var n = biHighIndex(x);
  597.     var t = biHighIndex(y);
  598.     var u, uv, k;
  599.  
  600.     for (var i = 0; i <= t; ++i) {
  601.         c = 0;
  602.         k = i;
  603.         for (j = 0; j <= n; ++j, ++k) {
  604.             uv = result.digits[k] + x.digits[j] * y.digits[i] + c;
  605.             result.digits[k] = uv & maxDigitVal;
  606.             c = uv >>> biRadixBits;
  607.             //c = Math.floor(uv / biRadix);
  608.         }
  609.         result.digits[i + n + 1] = c;
  610.     }
  611.     // Someone give me a logical xor, please.
  612.     result.isNeg = x.isNeg != y.isNeg;
  613.     return result;
  614. }
  615.  
  616. function biMultiplyDigit(x, y)
  617. {
  618.     var n, c, uv;
  619.  
  620.     result = new BigInt();
  621.     n = biHighIndex(x);
  622.     c = 0;
  623.     for (var j = 0; j <= n; ++j) {
  624.         uv = result.digits[j] + x.digits[j] * y + c;
  625.         result.digits[j] = uv & maxDigitVal;
  626.         c = uv >>> biRadixBits;
  627.         //c = Math.floor(uv / biRadix);
  628.     }
  629.     result.digits[1 + n] = c;
  630.     return result;
  631. }
  632.  
  633. function arrayCopy(src, srcStart, dest, destStart, n)
  634. {
  635.     var m = Math.min(srcStart + n, src.length);
  636.     for (var i = srcStart, j = destStart; i < m; ++i, ++j) {
  637.         dest[j] = src[i];
  638.     }
  639. }
  640.  
  641. var highBitMasks = new Array(0x0000, 0x8000, 0xC000, 0xE000, 0xF000, 0xF800,
  642.                              0xFC00, 0xFE00, 0xFF00, 0xFF80, 0xFFC0, 0xFFE0,
  643.                              0xFFF0, 0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF);
  644.  
  645. function biShiftLeft(x, n)
  646. {
  647.     var digitCount = Math.floor(n / bitsPerDigit);
  648.     var result = new BigInt();
  649.     arrayCopy(x.digits, 0, result.digits, digitCount,
  650.               result.digits.length - digitCount);
  651.     var bits = n % bitsPerDigit;
  652.     var rightBits = bitsPerDigit - bits;
  653.     for (var i = result.digits.length - 1, i1 = i - 1; i > 0; --i, --i1) {
  654.         result.digits[i] = ((result.digits[i] << bits) & maxDigitVal) |
  655.                            ((result.digits[i1] & highBitMasks[bits]) >>>
  656.                             (rightBits));
  657.     }
  658.     result.digits[0] = ((result.digits[i] << bits) & maxDigitVal);
  659.     result.isNeg = x.isNeg;
  660.     return result;
  661. }
  662.  
  663. var lowBitMasks = new Array(0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F,
  664.                             0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF,
  665.                             0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF);
  666.  
  667. function biShiftRight(x, n)
  668. {
  669.     var digitCount = Math.floor(n / bitsPerDigit);
  670.     var result = new BigInt();
  671.     arrayCopy(x.digits, digitCount, result.digits, 0,
  672.               x.digits.length - digitCount);
  673.     var bits = n % bitsPerDigit;
  674.     var leftBits = bitsPerDigit - bits;
  675.     for (var i = 0, i1 = i + 1; i < result.digits.length - 1; ++i, ++i1) {
  676.         result.digits[i] = (result.digits[i] >>> bits) |
  677.                            ((result.digits[i1] & lowBitMasks[bits]) << leftBits);
  678.     }
  679.     result.digits[result.digits.length - 1] >>>= bits;
  680.     result.isNeg = x.isNeg;
  681.     return result;
  682. }
  683.  
  684. function biMultiplyByRadixPower(x, n)
  685. {
  686.     var result = new BigInt();
  687.     arrayCopy(x.digits, 0, result.digits, n, result.digits.length - n);
  688.     return result;
  689. }
  690.  
  691. function biDivideByRadixPower(x, n)
  692. {
  693.     var result = new BigInt();
  694.     arrayCopy(x.digits, n, result.digits, 0, result.digits.length - n);
  695.     return result;
  696. }
  697.  
  698. function biModuloByRadixPower(x, n)
  699. {
  700.     var result = new BigInt();
  701.     arrayCopy(x.digits, 0, result.digits, 0, n);
  702.     return result;
  703. }
  704.  
  705. function biCompare(x, y)
  706. {
  707.     if (x.isNeg != y.isNeg) {
  708.         return 1 - 2 * Number(x.isNeg);
  709.     }
  710.     for (var i = x.digits.length - 1; i >= 0; --i) {
  711.         if (x.digits[i] != y.digits[i]) {
  712.             if (x.isNeg) {
  713.                 return 1 - 2 * Number(x.digits[i] > y.digits[i]);
  714.             } else {
  715.                 return 1 - 2 * Number(x.digits[i] < y.digits[i]);
  716.             }
  717.         }
  718.     }
  719.     return 0;
  720. }
  721.  
  722. function biDivideModulo(x, y)
  723. {
  724.     var nb = biNumBits(x);
  725.     var tb = biNumBits(y);
  726.     var origYIsNeg = y.isNeg;
  727.     var q, r;
  728.     if (nb < tb) {
  729.         // |x| < |y|
  730.         if (x.isNeg) {
  731.             q = biCopy(bigOne);
  732.             q.isNeg = !y.isNeg;
  733.             x.isNeg = false;
  734.             y.isNeg = false;
  735.             r = biSubtract(y, x);
  736.             // Restore signs, 'cause they're references.
  737.             x.isNeg = true;
  738.             y.isNeg = origYIsNeg;
  739.         } else {
  740.             q = new BigInt();
  741.             r = biCopy(x);
  742.         }
  743.         return new Array(q, r);
  744.     }
  745.  
  746.     q = new BigInt();
  747.     r = x;
  748.  
  749.     // Normalize Y.
  750.     var t = Math.ceil(tb / bitsPerDigit) - 1;
  751.     var lambda = 0;
  752.     while (y.digits[t] < biHalfRadix) {
  753.         y = biShiftLeft(y, 1);
  754.         ++lambda;
  755.         ++tb;
  756.         t = Math.ceil(tb / bitsPerDigit) - 1;
  757.     }
  758.     // Shift r over to keep the quotient constant. We'll shift the
  759.     // remainder back at the end.
  760.     r = biShiftLeft(r, lambda);
  761.     nb += lambda; // Update the bit count for x.
  762.     var n = Math.ceil(nb / bitsPerDigit) - 1;
  763.  
  764.     var b = biMultiplyByRadixPower(y, n - t);
  765.     while (biCompare(r, b) != -1) {
  766.         ++q.digits[n - t];
  767.         r = biSubtract(r, b);
  768.     }
  769.     for (var i = n; i > t; --i) {
  770.     var ri = (i >= r.digits.length) ? 0 : r.digits[i];
  771.     var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
  772.     var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
  773.     var yt = (t >= y.digits.length) ? 0 : y.digits[t];
  774.     var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
  775.         if (ri == yt) {
  776.             q.digits[i - t - 1] = maxDigitVal;
  777.         } else {
  778.             q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
  779.         }
  780.  
  781.         var c1 = q.digits[i - t - 1] * ((yt * biRadix) + yt1);
  782.         var c2 = (ri * biRadixSquared) + ((ri1 * biRadix) + ri2);
  783.         while (c1 > c2) {
  784.             --q.digits[i - t - 1];
  785.             c1 = q.digits[i - t - 1] * ((yt * biRadix) | yt1);
  786.             c2 = (ri * biRadix * biRadix) + ((ri1 * biRadix) + ri2);
  787.         }
  788.  
  789.         b = biMultiplyByRadixPower(y, i - t - 1);
  790.         r = biSubtract(r, biMultiplyDigit(b, q.digits[i - t - 1]));
  791.         if (r.isNeg) {
  792.             r = biAdd(r, b);
  793.             --q.digits[i - t - 1];
  794.         }
  795.     }
  796.     r = biShiftRight(r, lambda);
  797.     // Fiddle with the signs and stuff to make sure that 0 <= r < y.
  798.     q.isNeg = x.isNeg != origYIsNeg;
  799.     if (x.isNeg) {
  800.         if (origYIsNeg) {
  801.             q = biAdd(q, bigOne);
  802.         } else {
  803.             q = biSubtract(q, bigOne);
  804.         }
  805.         y = biShiftRight(y, lambda);
  806.         r = biSubtract(y, r);
  807.     }
  808.     // Check for the unbelievably stupid degenerate case of r == -0.
  809.     if (r.digits[0] == 0 && biHighIndex(r) == 0) r.isNeg = false;
  810.  
  811.     return new Array(q, r);
  812. }
  813.  
  814. function biDivide(x, y)
  815. {
  816.     return biDivideModulo(x, y)[0];
  817. }
  818.  
  819. function biModulo(x, y)
  820. {
  821.     return biDivideModulo(x, y)[1];
  822. }
  823.  
  824. function biMultiplyMod(x, y, m)
  825. {
  826.     return biModulo(biMultiply(x, y), m);
  827. }
  828.  
  829. function biPow(x, y)
  830. {
  831.     var result = bigOne;
  832.     var a = x;
  833.  
  834.     while (true) {
  835.         if ((y & 1) != 0) result = biMultiply(result, a);
  836.         y >>= 1;
  837.         if (y == 0) break;
  838.         a = biMultiply(a, a);
  839.     }
  840.     return result;
  841. }
  842.  
  843. function biPowMod(x, y, m)
  844. {
  845.     var result = bigOne;
  846.     var a = x;
  847.     var k = y;
  848.     while (true) {
  849.         if ((k.digits[0] & 1) != 0) result = biMultiplyMod(result, a, m);
  850.         k = biShiftRight(k, 1);
  851.         if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
  852.         a = biMultiplyMod(a, a, m);
  853.     }
  854.     return result;
  855. }
  856.  
  857.